package com.cyq.day27.homework;

import java.util.*;

public class homework1 {
    public static void main(String[] args) {
        test9();

    }

    public static void test1() {
        //一、产生10个1-100的随机数，并放到一个数组中，把数组中大于等于10的数字放到一个list集合中，并打印到控制台
        int[] num = new int[10];
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < num.length; i++) {
            num[i] = (int) (Math.random() * 100 + 1);
        }
        for (int a : num) {
            if (a >= 10) {
                list.add(a);
            }
        }
        for (Integer integer :
                list) {
            System.out.println(integer);
        }
    }

    public int listTest(ArrayList<Integer> al, Integer s) {
        //二、定义一个方法listTest(ArrayList<Integer> al, Integer s)，要求返回s在al里面第一次出现的索引，如果s没出现过返回-1。
        boolean flag = false;
        int index = 0;
        for (Integer integer : al) {
            if (integer == s) {
                index = al.indexOf(integer);
                flag = true;
            }
        }
        if (!flag) {
            return -1;
        }

        return index;
    }

    public static void test2() {
        //三、已知数组存放一批QQ号码，QQ号码最长为11位，
        //最短为5位 String[] strs = {"12345","67891","12347809933","98765432102","67891","12347809933"}。
        //将该数组里面的所有qq号都存放在LinkedList中，将list中重复元素删除，将list中所有元素分别用迭代器和增强for循环打印出来。
        String[] strs = {"12345", "67891", "12347809933", "98765432102", "67891", "12347809933"};
        List<String> list = new LinkedList<>();
        boolean flag=true;
        for (int i = 0; i < strs.length; i++) {
            for (int j = 0; j < i; j++) {
                if (strs[i].equals(strs[j])) {
                    flag=false;
                }
            }
            if (flag){
                list.add(strs[i]);
            }
        }
        for (String s : list) {
            System.out.println(s);
        }
        System.out.println("----------------");
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            String next = iterator.next();
            System.out.println(next);
        }
    }

    public void test3() {
        //四、双色球规则：双色球每注投注号码由6个红色球号码和1个蓝色球号码组成。
        // 红色球号码从1—33中选择；蓝色球号码从1—16中选择；请随机生成一注双色球号码。（要求同色号码不重复）
        int[] number = new int[7];
        for (int i = 0; i < number.length - 1; i++) {
            int index = (int) (Math.random() * 33 + 1);
            number[i] = index;
            //保证红色号码不重复
            for (int j = 0; j < i; j++) {
                if (number[i] == number[j]) {
                    i--;
                    break;
                }
            }
        }
        number[6] = (int) (Math.random() * 16 + 1);
    }

    public static void test4() {
        //五、分别用Comparable和Comparator两个接口对下列四位同学的成绩做降序排序，如果成绩一样，那在成绩排序的基础上按照年龄由小到大排序。
        //
        //| 姓名（String） | 年龄（int） | 分数（float） |
        //| --- | --- | --- |
        //| zhangsan  | 20 | 90.0F |
        //| lisi | 22  | 90.0F |
        //| wangwu | 20  | 99.0F |
        //| zhaoliu | 22  | 100.0F |
        //
        //
        //编写一个Student类用来实现Comparable<Student>接口,并在其中重写CompareTo(Student o)方法
        Student s1 = new Student("zhangsan", 20, 90.0F);
        Student s2 = new Student("lisi", 22, 90.0F);
        Student s3 = new Student("wangwu", 20, 99.0F);
        Student s4 = new Student("zhaoliu", 22, 100.0F);
        Set<Student> set=new TreeSet<Student>();
        set.add(s1);
        set.add(s2);
        set.add(s3);
        set.add(s4);
        for (Student s:set) {
            System.out.println(s);
        }

    }

    public static void test5() {
        //六、现在有一个map集合如下：
        Map<Integer,String> map = new HashMap<Integer, String>();
        map.put(1, "张三丰");
        map.put(2, "周芷若");
        map.put(3, "赵敏");
        map.put(4, "灭绝师太");
        //要求：
        //1.遍历集合，并将序号与对应人名打印。
        //2.向该map集合中插入一个编码为5姓名为李晓红的信息
        //3.移除该map中的编号为1的信息
        //4.将map集合中编号为2的姓名信息修改为"周林"
        Set<Map.Entry<Integer, String>> entries = map.entrySet();
        Iterator<Map.Entry<Integer, String>> iterator = entries.iterator();
        while (iterator.hasNext()){
            Map.Entry<Integer, String> next = iterator.next();
            System.out.println(next);
        }
        map.put(5,"李晓红");
        map.remove(1);
        map.replace(2,"周林");
    }

    public static void test6() {
        //七、有2个数组，第一个数组内容为：[黑龙江省,浙江省,江西省,广东省,福建省]，第二个数组为：[哈尔滨,杭州,南昌,广州,福州]
        // 将第一个数组元素作为key，第二个数组元素作为value存储到Map集合中。如{黑龙江省=哈尔滨, 浙江省=杭州, …}。
        List<String> list1 = new ArrayList<>();
        list1.add("黑龙江省");
        list1.add("浙江省");
        list1.add("江西省");
        list1.add("广东省");
        list1.add("福建省");
        List<String> list2 = new ArrayList<>();
        list2.add("哈尔滨");
        list2.add("杭州");
        list2.add("南昌");
        list2.add("广西");
        list2.add("福州");
        Map<String, String> map = new HashMap<>();
        for (int i = 0; i < list1.size(); i++) {
            map.put(list1.get(i), list2.get(i));
        }
        Set<Map.Entry<String, String>> entries = map.entrySet();
        Iterator<Map.Entry<String, String>> iterator = entries.iterator();
        while (iterator.hasNext()) {
            Map.Entry<String, String> next = iterator.next();
            System.out.println(next);
        }
    }

    public void test7() {
        //封装电影管理类
        //提示:
        //电影类Movie 属性 id,movieName,actor,price
        //电影管理类
        //电影管理类中有这样的方法
        //filter方法是电影的过滤方法，BookFilter是一个接口
        //这里的接口是一个规范
        //通过这个方法，可以过滤出我们想要的图书信息
        //public Movie[] filter(MovieFilter filter){}
        Movie movie1=new Movie(1,"Breaking bad","Aaron Paul",80);
        Movie movie2=new Movie(2,"Prison break","Wentworth Miller",100);
        Movie movie3=new Movie(3,"inception","Leonardo DiCarprio",150);
        MovieManager movieManager=new MovieManager();
        movieManager.add(movie1);
        movieManager.add(movie2);
        movieManager.add(movie3);
       List list=movieManager.filter(new MovieFilter() {
           @Override
           public boolean accept(Movie m) {
                if (m.getActor().indexOf("L")!=-1){
                return true;
               }
               return false;
           }
       });
    }

    public static void test8() {
        //九、使用Scanner从键盘读取一行输入，去掉其中重复字符，打印出不同的那些字符
        Scanner scanner = new Scanner(System.in);
        String input = scanner.next();
        List<String> list = new ArrayList<>();
        for (int i = 0; i < input.length(); i++) {
            String s = input.substring(i, i + 1);
            if (!list.contains(s)) {
                list.add(s);
            }
        }
        System.out.println(list);
    }

    public static void test9() {
        //十、生成10个10以内随机长度的字符串并排序，如"s5L9kP","l2IDhY","dfyMnc5"......
        //提示：
        //1、总共10个字符串
        //2、字符串的长度是随机的，10个长度以内就行
        //3、可以创建一个字符串池，所有字符串在池里面取出再随机组合，比如：
        //4、上面的字符串可以随机取出之后再拼接，比如
        //5、可以使用工具类排序
       String str= "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
        for (int i = 0; i <10 ; i++) {
            int length=(int)(Math.random()*10+1);
            String[] s1=new String[length];
            for (int j = 0; j <length ; j++) {
                int num=(int)(Math.random()*61+1);
                s1[j]=str.charAt(num)+"";
            }
            Arrays.sort(s1);
            for (String s:s1) {
                System.out.print(s);
            }
            System.out.println();
        }
    }

    public void test10() {
        //十一、使用Map模拟把不同的学生放入不同的班级，班级在不同的学校，该Map如何创建
        //Map<school,Map<grade,Map<StudentClass,StudentName> map=new HashMap<>();
        //十二、介绍Collection框架的结构
        //Collection：List列表，Set集
        //Map：Hashtable，HashMap，TreeMap
        //Collection  是单列集合
        //1.List   元素是有序的、可重复，有序的 collection，可以对列表中每个元素的插入位置进行精确地控制。可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。可存放重复元素，元素存取是有序的。
        //List接口中常用类
        // Vector： 线程安全，但速度慢，已被ArrayList替代。底层数据结构是数组结构
        // ArrayList：线程不安全，查询速度快。底层数据结构是数组结构
        // LinkedList：线程不安全。增删速度快。底层数据结构是列表结构
        //2.Set(集) 元素无序的、不可重复。取出元素的方法只有迭代器。不可以存放重复元素，元素存取是无序的。
        //Set接口中常用的类
        // HashSet：线程不安全，存取速度快。它依赖的是元素的hashCode方法和euqals方法保证元素唯一性。
        // TreeSet：线程不安全，可以对Set集合中的元素进行排序。它通过compareTo或者compare方法中的来保证元素的唯一性。元素是以二叉树的形式存放的。
        //3.Map  是一个双列集合
        // Hashtable:线程安全，速度快。底层是哈希表数据结构。是同步的。不允许null作为键，null作为值。
        // Properties:用于配置文件的定义和操作，使用频率非常高，同时键和值都是字符串。是集合中可以和IO技术相结合的对象。(到了IO在学习它的特有和io相关的功能。)
        // HashMap:线程不安全，速度慢。底层也是哈希表数据结构。是不同步的。允许null作为键，null作为值。替代了Hashtable.
        // LinkedHashMap: 可以保证HashMap集合有序。存入的顺序和取出的顺序一致。
        // TreeMap：可以用来对Map集合中的键进行排序
        //十三、Collection框架中实现比较要实现什么接口
        //(1)Comparable接口
        // 是需要比较的类实现自己实现，例如：定义的Student类需要比较,需要Student类自己实现这个接口，实现ComParaTo()方法。
        // (2)Comparator接口
        // 自己定义一个比较容器，去实现这个接口（实现compare方法），然后在集合生成的时候，用一个比较对象做参数，跟集合绑定。
        //十四、ArrayList和Vector的区别（是否有序、是否重复、数据结构、底层实现）
        //1、Vector是线程安全的，ArrayList不是线程安全的。
        //2、ArrayList在底层数组不够用时在原来的基础上扩展0.5倍，Vector是扩展1倍。
        //3.Vector和ArrayList都是有序且可以重复的
        //十五、LinkedList和ArrayList的区别
        //1.ArrayList的底层是数组和LinkedList的底层是链表
        //2.ArrayList查询效率高，删除和插入效率低。而LinkedList查询效率低，删除和插入效率高
        //3.LinkedList有自己独有的方法，addfirst(),addlast()，removefirst(),removelast()
        //十六、List 和 Set 区别
        //List都是有序的，且其中的元素可以重复
        //Set无序，且其中的元素不能重复
        //十七、List 和 Map 区别
        //1.性质不同：list是储存单列数据的集合，map是存储Key-Value键值对的双列数据集合
        //2.顺序不同：list存储的数据是有顺序的，map存储的数据是没有顺序的
        //3.重复不同：list存储的数据允许重复，map存储的数据key是不能重复的，value是可以重复的
        //十八、List、Map、Set三个接口，存取元素时，各有什么特点？
        //List与Set都是单列元素的集合，它们有一个功共同的父接口Collection。
        //Set里面不允许有重复的元素，
        //存元素：add方法有一个boolean的返回值，当集合中没有某个元素，此时add方法可成功加入该元素时，则返回true；当集合含有与某个元素equals相等的元素时，此时add方法无法加入该元素，返回结果为false。
        //取元素：没法说取第几个，只能以Iterator接口取得所有的元素，再逐一遍历各个元素。
        //List表示有先后顺序的集合，
        //存元素：多次调用add(Object)方法时，每次加入的对象按先来后到的顺序排序，也可以插队，即调用add(int index,Object)方法，就可以指定当前对象在集合中的存放位置。
        //取元素：方法1：Iterator接口取得所有，逐一遍历各个元素
        //        方法2：调用get(index i)来明确说明取第几个。
        //Map是双列的集合，存放用put方法:put(obj key,obj value)，每次存储时，要存储一对key/value，不能存储重复的key，这个重复的规则也是按equals比较相等。
        //取元素：用get(Object key)方法根据key获得相应的value。
        //        也可以获得所有的key的集合，还可以获得所有的value的集合，
        //        还可以获得key和value组合成的Map.Entry对象的集合。
        //List以特定次序来持有元素，可有重复元素。Set 无法拥有重复元素,内部排序。Map 保存key-value值，value可多值
    }

}
